Dynamically configurable and re-configurable data path

ABSTRACT

An apparatus includes a configuration memory coupled to one or more structural arithmetic elements, the configuration memory to store values that cause the structural arithmetic elements to perform various functions. The apparatus also includes a system controller to dynamically load the configuration memory with values, and to prompt the structural arithmetic elements to perform functions according to the values stored by the configuration memory.

RELATED APPLICATIONS

The present application claims priority to U.S. Provisional Application No. 60/912,399, filed Apr. 17, 2007 and is herein incorporated by reference in its entirety.

TECHNICAL FIELD

The present disclosure relates generally to programmable devices, and more particularly to a Universal Digital Block (UDB) with a dynamic configuration memory.

BACKGROUND

Field-programmable gate arrays (FPGAs) and programmable logic devices (PLDs) have been used in data communication and telecommunication systems. Conventional PLDs and FPGAs consist of an array of programmable elements, with the elements programmed to implement a fixed function or equation. Some currently-available Complex PLD (CPLD) products comprise arrays of logic cells. Conventional PLD devices have several drawbacks, such as high power consumption and large silicon area.

In developing complex electronic systems, there is often a need for additional peripheral units, such as operational and instrument amplifiers, filters, timers, digital logic circuits, analog to digital and digital to analog converters, etc. As a general rule, implementation of these extra peripherals create additional difficulties: extra space for new components, additional attention during production of a printed circuit board, and increased power consumption. All of these factors can significantly affect the price and development cycle of the project.

The introduction of Programmable System on Chip (PSoC) chips feature digital and analog programmable blocks, which allow the implementation of a large number of peripherals. A programmable interconnect allows analog and digital blocks to be combined to form a wide variety of functional modules. The digital blocks consist of smaller programmable blocks and are configured to provide different digital functions. The analog blocks are used for development of analog elements, such as analog filters, comparators, inverting amplifiers, as well as analog to digital and digital to analog converters. Current PSoC architectures provide only a coarse grained digital programmability in which a few fixed functions with a small number of options are available.

SUMMARY

An apparatus comprising a configuration memory coupled to one or more structural arithmetic elements, the configuration memory to store values that cause the structural arithmetic elements to perform various functions, and a system controller to dynamically load the configuration memory with values, and to prompt the structural arithmetic elements to perform functions according to the values stored by the configuration memory.

The apparatus further including a read address decoder associated with the configuration memory, the read address decoder to receive input from the system controller or system interconnect and determine one or more of the stored values to provide to the structural arithmetic elements. The apparatus further including a write address decoder associated with the configuration memory, the write address decoder to identify a location in the configuration memory to dynamically store values from the system controller. The apparatus including a write controller associated with the configuration memory, the write controller to enable the system controller to dynamically load values to the location in the configuration memory identified by the write address decoder.

The stored values include a function field that identifies a type of arithmetic operation to be performed by the structural arithmetic elements. The stored values include an input field to specify input data for use with the arithmetic operation corresponding to the function field, and include an output field to specify where the structural arithmetic elements are to provide an output associated with a performed arithmetic operation. The stored values include a shift field to specify a shift data undergoing arithmetic operations. The stored values include a configuration field to identify one or more configurations of the structural arithmetic elements including at least one of a cyclical redundancy check configuration, a carry in configuration, a shift in configuration, or a compare configuration. The configuration field identifies the one or more configurations of the structural arithmetic elements from multiple predefined static settings.

A device comprising at least one structural arithmetic elements to perform various arithmetic operations based, at least in part, on configuration data, and a configuration memory coupled to the structural arithmetic elements, the configuration memory to dynamically load configuration data that, when provided to the structural arithmetic elements, cause the structural arithmetic elements to perform the arithmetic operations.

The device further including a system controller to dynamically load the configuration memory with the configuration data, and to prompt the structural arithmetic elements to perform the arithmetic operations according to the configuration data stored by the configuration memory. The device further including a read address decoder associated with the configuration memory, the read address decoder to receive input from the system controller and determine one or more of the stored values to provide to the structural arithmetic elements. The device further including a write address decoder associated with the configuration memory, the write address decoder to identify a location in the configuration memory to dynamically store the configuration data from the system controller. The device further including a write controller associated with the configuration memory, the write controller to enable the system controller to dynamically load the configuration data to the location in the configuration memory identified by the write address decoder.

The stored values include a function field that identifies a type of arithmetic operation to be performed by the structural arithmetic elements. The stored values include an input field to specify input data for use with the arithmetic operation corresponding to the function field, and include an output field to specify where the structural arithmetic elements are to provide an output associated with a performed arithmetic operation.

A method comprising storing one or more user programmable instructions into a configuration memory, providing at least one of the user programmable instructions to one or more structural logic elements, the structural logic elements to perform a corresponding user programmed logic function according to the received user programmable instructions, and dynamically reprogramming the configuration memory with at least another user programmable instruction that, when provided to the structural logic elements, cause the structural logic elements to perform corresponding user programmed logic functions according to the received user programmable instructions

The method can also include writing a new set of instructions while a separate set of instructions are currently being read and are currently controlling the datapath structural elements. Then in response to a system event, the system controller can switch the inputs to address the new set of instructions, thus dynamically reconfiguring the datapath structural elements to perform a new function.

The method can also include identifying one or more of the stored user programmable instruction to provide to the structural logic elements according to an input received from a system controller. The method can also include identifying a location in the configuration memory to load the user programmable instruction from the system controller during the dynamic reprogramming.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic block diagram illustrating an example Programmable System on a Chip (PSoC) architecture that includes a Universal Digital Block (UDB) array.

FIG. 2 is a schematic block diagram illustrating one of the UDBs in FIG. 1 that includes both uncommitted PLD blocks and a structural dedicated datapath block.

FIG. 3 is a schematic block diagram illustrating the UDB in FIG. 2 in more detail.

FIG. 4 is a schematic block diagram also showing a datapath block in FIG. 2 in more detail.

FIG. 5 is a schematic block diagram illustrating example embodiments of the datapath block shown in FIG. 4.

FIG. 6 is a schematic block diagram illustrating example embodiments of the dynamic configuration memory shown in FIG. 4.

FIG. 7 is a schematic block diagram showing example embodiments of configuration data shown in FIG. 4 and FIG. 5.

FIG. 8 is a schematic block diagram showing how the UDBs are programmed using configuration registers.

FIG. 9 is a flow diagram showing how a micro-controller or other Central Processing Unit (CPU) programs the UDBs.

DETAILED DESCRIPTION

A new Universal Digital Block (UDB) architecture combines PLDs and a datapath module in the same digital logic block to allow for the implementation of universal embedded digital functions. The new UDB architecture includes an integrated ALU that removes limitations associated with fixed functionality and provides users with the ability to customize digital operations to match system requirements.

FIG. 1 is a high level view of a Universal Digital Block (UDB) array 110 contained within a Programmable System on a Chip (PSoC) Integrated Circuit (IC) 100. The UDB array 110 includes a programmable interconnect matrix 130 that connects together different UDBs 120. The individual UDBs 120 each include a collection of uncommitted logic in the form of Programmable Logic Devices (PLDs) and structural dedicated logic elements that form a datapath 210 shown in more detail in below.

UDB Array

The UDB array 110 is arranged into UDB pairs 122 that are connected together through the interconnect matrix 130. The UDB pairs 122 each include two UDBs 120 that can be tightly coupled to a shared horizontal routing channel 132. The UDB pairs 122 can also be programmably connected to the horizontal routing channels 132 of other UDB pairs 122 either in the same horizontal row or in different rows through vertical routing channels 134. The horizontal and vertical routing channels and other switching elements are all collectively referred to as the interconnect matrix 130.

A Digital System Interconnect (DSI) routing interface 112 connects a micro-controller system 170 and other fixed function peripherals 105 to the UDB array 110. The micro-controller system 170 includes a micro-controller 102, an interrupt controller 106, and a Direct Memory Access (DMA) controller 108. The other peripherals 105 can be any digital or analog functional element that is preconfigured in PSoC 100. The DSI 112 is an extension of the interconnect matrix 130 at the top and bottom of the UDB array 110.

UDB

FIG. 2 is a top-level block diagram for one of the UDBs 120. The major blocks include a pair of Programmable Logic Devices (PLDS) 200. The PLDs 200 take inputs from the routing channel 130 and form registered or combinational sum-of-products logic to implement state machines, control for datapath operations, conditioning inputs and driving outputs.

The PLD blocks 200 implement state machines, perform input or output data conditioning, and create look-up tables. The PLDs 200 can also be configured to perform arithmetic functions, sequence datapath 210, and generate status. PLDs are generally known to those skilled in the art and are therefore not described in further detail.

The datapath block 210 contains highly structured dedicated logic that implements a dynamically programmable ALU, comparators, and condition generation. A status and control block 204 allows micro-controller firmware to interact and synchronize with the UDB 120 by writing to control inputs and reading status outputs.

A clock and reset control block 202 provides global clock selection, enabling, and reset selection. The clock and reset block 202 selects a clock for each of the PLD blocks 200, the datapath block 210, and status and control block 204 from available global system clocks or a bus clock. The clock and reset block 202 also supplies dynamic and firmware resets to the UDBs 120.

Routing channel 130 connects to UDB I/O through a programmable switch matrix and provides connections between the different elements of the UDBs in FIG. 2. A system bus interface 140 maps all registers and RAMs in the UDBs 120 into a system address space and are accessible by the micro-controller 102 shown in FIG. 1.

The PLDs 200 and the datapath 210 have chaining signals 212 and 214, respectively, which enable neighboring UDBs 120 to be linked to create higher precision functions. The PLD carry chain signals 212 are routed from the previous adjacent UDB 120 in the chain, and routed through each macrocell in both of the PLDs 200. The carry out is then routed to the next UDB 120 in the chain. A similar connectivity is provided for the set of conditional signals generated by the datapath chain 214 between datapath blocks 210 in adjacent UDBs 120.

Referring to FIG. 3, each UDB 120 comprises a combination of user defined control bits that are loaded by the micro-controller 102 into control register 250. The control register 250 is part of the control blocks 202 and 204 described above in FIG. 2. The control register 250 feeds uncommitted programmable logic 200 and control for datapath inputs. The same control blocks 202 and 204 described above in FIG. 2 also include associated status registers 256 that allow the micro-controller 102 to selectable read different internal states for both the uncommitted logic elements and structural arithmetic elements 254 within the datapath 210.

The datapath 210 comprises highly structured logic elements 254 that include a dynamically programmable ALU 304, conditional comparators 310, accumulators 302, and data buffers 300. The ALU 304 is configured to perform instructions on accumulators 302, and to perform arithmetic sequences as controlled by a sequence memory. The conditional comparators 310 can operate in parallel with the ALU 304. The datapath 210 is further optimized to implement typical embedded functions, such as timers, counters, pseudo random sequence generators, Cyclic Redundancy Checkers (CRC), Pulse Width Modulators (PWM), etc.

The combination of uncommitted PLDs 200 with a dedicated datapath module 210 allow the UDBs 120 to provide embedded digital functions with more silicon efficient processing. The dedicated committed structural arithmetic elements 254 more efficiently implement arithmetic sequencer operations, as well as other datapath functions. Since the datapath 210 is structural, fewer gates are needed to implement these structural elements 254 and fewer interconnections are needed to connect the structural elements 254 together into an arithmetic sequencer. Implementing the same datapath 210 with PLDs could require a much greater quantity of additional combinational logic and additional interconnections.

The structured logic in the datapath 210 is also highly programmable to provide a wide variety of different dynamically selectable arithmetic functions. Thus, the datapath 210 not only conserves space on the integrated circuit 100 (FIG. 1) but also is highly configurable similar to PLDs. It has an additional advantage of being dynamically configurable and reconfigurable.

The functionality of the datapath 210 may be controlled through writes to the control registers 250 allowing the micro-controller 102 to arbitrarily set the system state and selectively control different arithmetic functions. The status registers 256 allow the micro-controller 102 to also identify different states associated with different configured arithmetic operations. The flexible connectivity scheme provided by the routing channel 130 selectively interconnects the different functional element 250, 200, 254, and 256 together as well as programmably connecting these functional elements to other UDBs, I/O connections, and peripherals.

Thus, the combination of uncommitted logic 252, structural logic 254, and programmable routing channel 130 provide as much functionality and uses less integrated circuit space, while at the same time providing the potential for increased performance and substantially the same functional configurability.

Datapath

FIG. 4 shows one embodiment of the datapath 210 in more detail. The datapath 210 contains a single cycle ALU 304 and associated conditional logic comparators 310. The datapath 210 can be chained with neighboring datapaths to achieve single cycle functionality with additional bit widths. A RAM based control store 324 dynamically selects the operation and configuration performed in any given cycle.

The datapath 210 is optimized to implement typical embedded functions, such as timers, counters, Pulse Width Modulators (PWMs), Pseudo Random Sequence (PRS) generators, Cyclic Redundancy Checks (CRC), shifters, dead band generators, etc. The addition of the add and subtract functions in ALU 304 also allow support for digital delta-sigma operations.

Internal connections 330 can be externally connected to either the system bus 140 and/or the routing channel 130. Different combinations of connections 330 are interconnected between different datapath components according to their related functions. Connections 330 are shown as a single bus in FIG. 4 for illustrative purposes only and there may or may not be certain connections that are shared by multiple different datapath components.

Dynamic configuration is the ability to change the datapath function and interconnect configuration on a cycle-by-cycle basis. This is implemented using the information in configuration RAM 324. The address 323 input to RAM 324 can be routed from any functional element connected to the routing channel 130, and most typically include the PLDs 200 (FIG. 2), I/O pins 104 (FIG. 1), micro-controller 102 (FIG. 6), or PLDs or datapaths from other UDBs 120.

The ALU 304 can perform different general-purpose functions such as increment, decrement, add, subtract, logical AND, OR, XOR, or PASS. In addition to these functions, hardware structures and connections are provided to implement a single cycle CRC operation. In addition to the ALU 304, an independent shifter 306 provides left, right, nibble swap operations. Another independent masking function 308 masks selectable bits output from the ALU 304.

Each datapath 210 includes conditional logic comparators 310 which can be configured to receive a variety of different datapath register inputs. The comparators 310 check for conditions such as zero detect, all one's detect, and overflow. These conditions produce datapath outputs that are selectively routed back through the same datapath 210 or routed through output multiplexer 326 and the routing channel 130 to other UDBs or peripheral components.

Each datapath 210 contains multiple FIFOs 312 that can be individually configured to operate as input buffers or output buffers. When operating as input buffers, the system bus 140 can write to the FIFOs 312 and datapath internal logic elements can read from the FIFOs 312. When operating as output buffers, datapath internal logic elements write to the FIFO 312 and the system bus 140 reads from the FIFO 312. The FIFOs 312 generate status that can be routed to interact with sequencers, interrupt, or DMA requests.

As described above in FIG. 2, the datapath 210 can be configured to chain conditions and signals with neighboring datapaths. The shift, carry, capture, and other conditional signals can also be chained to form higher precision arithmetic, shift, and CRC/PRS functions. For example, 16-bit functions in an 8-bit datapath can be provided by interconnecting two datapaths together, or CRC generation can be implemented between two datapaths 210 using data shifting.

In applications that are oversampled, or don't need the highest clock rates, the ALU block 304 can be efficiently shared with two sets of registers and condition generators. Selected outputs from the ALU 304 and shifter 306 are registered and can be used as inputs in subsequent cycles.

The datapath 210 receives configuration inputs, control inputs, and data inputs. Some data inputs over input 320 are used for selecting the current address 323 for configuration RAM 324. Input 320 can come from either to the system bus 140 and/or to the routing channel 130. Control inputs can come over the system bus 140 or the routing channel 130 and are used to load the data registers 314 and capture outputs from accumulators 302. Data inputs can also come from the system bus 140 and/or the routing channel 130 and can include shift in and carry in signals received over input multiplexer 322. Other data inputs include parallel data input and output ports 318 that can be programmably connected through the routing channel 130 to the ALU 304.

There are multiple conditional, data, and status signals that can be selectively output via output multiplexer 326. For maximum routing flexibility, any of the status or data output signals connected to output mux 326 can be programmably connected to the routing channel 130.

The datapath 210 has multiple working registers. These registers are readable and writable by the micro-controller 102 and DMA 108 in FIG. 1. The accumulators 302 can be a source for the ALU 304 and a destination of the ALU output. The accumulators 302 can also be loaded from an associated data register 314 or FIFO 312. The accumulators 302 contain the current value of the ALU function, for example, the count, CRC or shift.

Dynamic Datapath Configuration and Programmability

FIG. 5 describes in more detail the dynamic configuration memory 324 shown in FIG. 4 and the interconnection between the dynamic configuration memory 324 and other structural arithmetic elements in the datapath block 210. Referring to FIG. 5, the dynamic configuration memory 324 can include multiple data words, values, or configuration instructions 340. These configuration instructions 340 can configure the datapath block 210 to perform various functions or to alter the interconnection of the datapath block 210 with other elements of the PSoC IC 100. In some embodiments, the configuration instructions 340 can be 16 bits long and contain multiple fields.

An address decoder 322 can receive inputs, for example, from the micro-controller 170 or other external CPU, or the interconnect matrix 130 and determine which of the configuration instructions 340 stored in the dynamic configuration memory 324 to provide to the structural arithmetic elements in the datapath block 210. The inputs can be an address that the address decoder 322 decodes to determine the location of the configuration instructions 340 in the dynamic configuration memory 324. In some embodiments, the address can be compressed and thus reduce utilization of routing resources in the PSoC IC 100, for example, reducing bandwidth consumption when routing the address to the datapath block 210 via the system bus 140.

When a configuration instruction 340 is selected by address decoder 322, the dynamic configuration memory 324 provides the selected configuration instruction 340 to one or more of the structural arithmetic elements in the datapath block 210. For example, the configuration instruction 340 can provide an ALU function to the ALU 304, can specify a data input source SRC for the ALU 304, and identify a destination DEST in the accumulators 302 for any output. The configuration instruction 340 can also identify a shift function to the independent shifter 306, such as shift left, shift right, pass, and nibble swap operations. The configuration instruction 340 can direct the first-in-first-out buffers 312 to push or pop data or direct the data registers 314 to load data associated with the ALU function identified by the configuration instruction 340. Embodiments of the configuration instructions 340 will be described below in greater detail in FIG. 7.

The micro-controller 170 or other external CPU can dynamically populate the dynamic configuration memory 324 with the configuration instructions 340, for example, through write operations via the system bus 140. This allows the users of the PSoC IC 100 to program and re-program the datapath block 210 on-the-fly by storing various configuration instructions 340 in the dynamic configuration memory 324. In other words, by including a dynamic configuration memory 324, the datapath block 210 becomes programmable by users of the PSoC IC 100, thus controlling the operations performed by the datapath block 210 and the interconnections by the datapath block 210 with other elements in the PSoC IC 100.

FIG. 6 is a schematic block diagram illustrating example embodiments of the dynamic configuration memory 324 shown in FIG. 4, Referring to FIG. 6, as shown and described above, the dynamic configuration memory 324 stores configuration instructions 340 for the datapath block 210. These configuration instructions 340 can be read from the dynamic configuration memory 324 responsive to inputs received by the address decoder 322.

Since the dynamic configuration memory 324 can be re-programmed by the micro-controller 170 or other external CPU, the datapath block 210 includes a write address decoder 352 and a write controller 354. The combination of the write address decoder 352 and a write controller 354 can control the loading or storing of configuration instructions 340 to the dynamic configuration memory 324. For instance, the write address decoder 352 can receive one or more addresses, e.g., from the micro-controller 170 or other external CPU, that indicate at least one location in the dynamic configuration memory 324 to store the configuration instruction 340. The write controller 354 can receive at least one write signal that enables the micro-controller 170 or other external CPU to write the configuration instructions 340 to the dynamic configuration memory 324. The micro-controller 170 or other external CPU can write the configuration instruction 340 to the dynamic configuration memory 324 through the system bus 140. Since the microcontroller 170 can access the write controller 354 separately from accessing the address decoder 322 used for reading configuration instructions 340 from the dynamic configuration memory 324, this microcontroller 170 can write into a set of memory locations that are not currently in the set of memory locations that are currently being read as controlled by the inputs 323 and address decoder 322. Therefore, the microcontroller 170, in response to a system event can write a new set of configuration instructions 340 while the previous set of configuration instructions 340 are being read, and then dynamically switch to the new set of configuration instructions 340 on-the-fly, changing the function of the datapath block 210 to address a new requirement in the PSoC IC 100.

In some embodiments, one or more of the configuration instructions 340 can be read to the system bus 140 from the dynamic configuration memory 324 for use by the micro-controller 170 or other external CPU in testing or verification. In this case, the write address decoder 352 and write controller 354 can be utilized to read the configuration instructions 340 from the dynamic configuration memory 324 to the system bus 140 for the micro-controller 170 or other external CPU.

The dynamic configuration memory 324 can be logically bifurcated when accessed by the micro-controller 170 or other external CPU, i.e., have two or more memory addresses associated with a single configuration instruction 340. In the example embodiment shown in FIG. 6, each configuration instruction 340 has one address during read operations to the datapath block 210, and has two addresses when the micro-controller 170 or other external CPU access the dynamic configuration memory 324 through the system bus 140.

FIG. 7 is a schematic block diagram showing example embodiments of configuration data shown in FIG. 4 and FIG. 5. Referring to FIG. 7, the configuration instruction 340 includes an ALU function(s) field 341 to identify an ALU function associated with the configuration instruction 340. When selected to be processed by the datapath block 210, the configuration instruction 340 provides the ALU function identified by the ALU function field 341 to the ALU 304.

The configuration instruction 340 includes an ALU input(s) field 342 to identify the input data to the ALU 304 for the given ALU function. The configuration instruction 340 can provide a source signal SRC to a multiplexer that selects between static data and data from an accumulator 302 responsive to the source signal SRC. In some embodiments, each of the inputs can have a separate field in the configuration instruction 340.

The configuration instruction 340 includes an ALU output(s) field 343 to specify a location for an output derived from the ALU function. In some embodiments, the configuration instruction 340 can provide a destination signal DEST to the accumulators 302, which identifies where the output is to be stored. In some embodiments, each of the outputs can have a separate field in the configuration instruction 340.

The configuration instruction 340 includes a shift function(s) field 344 to provide a shift function to an independent shifter 306. The independent shifter 306 can perform shift left, shift right, pass, and nibble swap operations on data from the ALU and provide the data to an independent masking function 308. In some embodiments, the independent masking function 308 can mask selectable bits output from the ALU 304 or independent shifter 306.

The configuration instruction 340 includes a specialized configuration(s) field 345 to indicate any specialized configuration of the datapath block 210 desired for the given configuration instruction 340. For instance, the specialized configuration(s) field 345 can identify at least one of cyclical redundancy check configuration, a carry in configuration, a shift in configuration, or a compare configuration for the datapath block 210. For these configurations, the dynamic configuration memory 324 can select among multiple predefined static settings, for example, stored in a static register (not shown). In some embodiments, each of the specialized configurations can have a separate field in the configuration instruction 340.

Dynamic UBD Configuration and Programmability

FIGS. 8 and 9 describe in more detail how the PSoC chip provides both static and dynamic programmability and configuration. The micro-controller 102, or some other equivalent programmable CPU, receives external data and control signals from a variety of different Input/Output pins 104. The micro-controller 102 can also receive internal signals from different internal peripherals, such as the UDB array 110, over the interconnect matrix 130.

A Random Access Memory (RAM) and/or a set of configuration registers 410 are directly readable and writeable by the micro-controller 102. Some memory locations 412 are associated with PLD configuration. For example, the micro-controller 102 can write values into memory locations 412 to program how different PLDs 200 operate and how the PLDs 200 are connected with other PLDs 200 and datapaths 210 in the same or in other UDBs 120. Similarly, the micro-controller 102 can write values into memory locations 416 to configure different arithmetic operations in the datapaths 210 and configure routing interconnections between the datapaths 210 and other functional elements in the PSoC IC 100.

The memory section (or configuration registers) 410 is used to program different arithmetic operations performed by the datapath 210 and different interconnect matrix routing that may be used for these different arithmetic operations. For example, the values in memory locations 410 can determine which internal signals from the ALU 304 in FIG. 4 are output from MUX 326.

FIG. 8 also shows the system bus 140 and routing channel 130 connections between the micro-controller 102, RAM/configuration registers 410, and UDB array 110. This illustrates how a variety of different connections are used to both configure the UDB array 110 and transfer data in and out of the UDB array 110. The RAM/configuration registers 410 are shown as a separate memory element in FIG. 8 for illustrative purposes. However, it should be understood that some or all of the configuration registers 410 can be located in the individual UDBs 120 and in other peripheral elements. Other configuration registers 410 can be stand alone registers that are separately coupled to one or more of the peripheral elements.

Referring both to FIGS. 8 and 9, the micro-controller 102 writes values into random access configuration registers 410 to configure both the connectivity and functionality of the UDB array 110. For example, the micro-controller 102 may load PLD configuration values into configuration registers 412, load datapath configuration values into configuration registers 414, and load routing configuration values for configuring the routing matrix 130 into configuration registers 416.

The micro-controller 102 can then monitor different internal or external events in operation 232. For example, the micro-controller 102 may monitor external signals on I/O pin 104 or may monitor different internal signals or states in the UDB array 110. A particular external or internal signal or state may be detected in operation 234 that requires a new UDB functional operation and/or a new routing configuration.

For example, the micro-controller 102 may detect a signal that requires increased accuracy for a subsequent arithmetic operation. Accordingly, the micro-controller 102 in operation 236 writes different values into particular locations 412, 414, and/or 416 of configuration RAM 410 that reconfigure the UDB array 110 for the new arithmetic operation and/or new interconnect configuration.

In this example, the micro-controller 102 can determine based on some monitored event that both datapath_(—)1 and datapath_(—)3 need to process a set of data. A previous operation may have compared two 8 bit wide data values. However, the micro-controller 102 determines that a next operation requires two 16 bit wide data values to be added together. The micro-controller 102 writes values into RAM section 414 that change the functions performed in the ALUs 304 and/or comparators 310 in datapath_(—)1 and datapath_(—)3 from 8 bit compare operations to a 16 bit add operation.

The micro-controller 102 may also need to reconfigure the interconnect matrix 130 so that the first datapath_(—)1 adds together the first 8 bits of the two data values and datapath_(—)3 adds together the second 8 bits of the two data values. Accordingly, the micro-controller 102 writes values into memory location 416 that connect datapath_(—)1 and datapath_(—)3 together through the interconnect matrix 130 to form a 16 bit wide adder. The new values loaded into memory sections 414 and 416 also connect the carry output 214 (FIG. 2) from datapath_(—)1 with the carry input 214 from datapath_(—)3.

The two halves of the two 16 bit data values are loaded into the data registers 314 (FIG. 4) of datapath_(—)1 and datapath 3, respectively, by the micro-controller 102. A 16 bit add operation is then performed on the 16 bit wide data values by the dynamically programmed 16 bit ALU configured using datapath_(—)1 and datapath 3. This of course is just one example of any number of different arithmetic operations that can be dynamically configured using the UDB array 110.

The micro-controller 102 can then switch the input address sequence to new values in memory section 410 in operation 238. For example, the micro-controller 102, in response to a system event, can write a new set of configuration instructions 340 while the previous set of configuration instructions 340 are being read from the configuration registers 410, and then dynamically switch to the new set of configuration instructions 340 on-the-fly, changing the function of the datapath block 210 to address a new requirement in the PSoC IC 100. The system described above can use dedicated processor systems, micro controllers, programmable logic devices, or microprocessors that perform some or all of the operations. Some of the operations described above can be implemented in software and other operations can be implemented in hardware.

For the sake of convenience, the operations are described as various interconnected functional blocks or distinct software modules. This is not necessary, however, and there can be cases where these functional blocks or modules are equivalently aggregated into a single logic device, program or operation with unclear boundaries. In any event, the functional blocks and software modules or features of the flexible interface can be implemented by themselves, or in combination with other operations in either hardware or software.

Having described and illustrated the principles of the invention in a preferred embodiment thereof, it should be apparent that the invention can be modified in arrangement and detail without departing from such principles. Claim is made to all modifications and variation coming within the spirit and scope of the following claims. 

1. An apparatus, comprising: a configuration memory coupled to one or more structural arithmetic elements, the configuration memory to store values that cause the structural arithmetic elements to perform various functions; and a system controller to dynamically load the configuration memory with values, and to prompt the structural arithmetic elements to perform functions according to the values stored by the configuration memory.
 2. The apparatus according to claim 1 including a read address decoder associated with the configuration memory, the read address decoder to receive input from the system controller or interconnect matrix inputs and determine one or more of the stored values to provide to the structural arithmetic elements.
 3. The apparatus according to claim 2 including a write address decoder associated with the configuration memory, the write address decoder to identify a location in the configuration memory to dynamically store values from the system controller.
 4. The apparatus according to claim 3 including a write controller associated with the configuration memory, the write controller to enable the system controller to dynamically load values to the location in the configuration memory identified by the write address decoder.
 5. The apparatus according to claim 1 wherein the stored values include a function field that identifies a type of arithmetic operation to be performed by the structural arithmetic elements.
 6. The apparatus according to claim 5 wherein the stored values include an input field to specify input data for use with the arithmetic operation corresponding to the function field, and include an output field to specify where the structural arithmetic elements are to provide an output associated with a performed arithmetic operation.
 7. The apparatus according to claim 6 wherein the stored values include an shift field to specify a shift data undergoing arithmetic operations.
 8. The apparatus according to claim 7 wherein the stored values include an configuration field to identify one or more configurations of the structural arithmetic elements including at least one of a cyclical redundancy check configuration, a carry in configuration, a shift in configuration, or a compare configuration.
 9. The apparatus according to claim 8 wherein the configuration field identifies the one or more configurations of the structural arithmetic elements from multiple predefined static settings.
 10. A device comprising: at least one structural arithmetic elements to perform various arithmetic operations based, at least in part, on configuration data; and a configuration memory coupled to the structural arithmetic elements, the configuration memory to dynamically load configuration data that, when provided to the structural arithmetic elements, cause the structural arithmetic elements to perform the arithmetic operations.
 11. The device according to claim 10 including a system controller to dynamically load the configuration memory with the configuration data, and to prompt the structural arithmetic elements to perform the arithmetic operations according to the configuration data stored by the configuration memory.
 12. The device according to claim 11 including a read address decoder associated with the configuration memory, the read address decoder to receive input from the system controller or interconnect matrix inputs and determine one or more of the stored values to provide to the structural arithmetic elements.
 13. The device according to claim 12 including a write address decoder associated with the configuration memory, the write address decoder to identify a location in the configuration memory to dynamically store the configuration data from the system controller.
 14. The device according to claim 13 including a write controller associated with the configuration memory, the write controller to enable the system controller to dynamically load the configuration data to the location in the configuration memory identified by the write address decoder.
 15. The device according to claim 10 wherein the stored values include a function field that identifies a type of arithmetic operation to be performed by the structural arithmetic elements.
 16. The device according to claim 15 wherein the stored values include an input field to specify input data for use with the arithmetic operation corresponding to the function field, and include an output field to specify where the structural arithmetic elements are to provide an output associated with a performed arithmetic operation.
 17. A method, comprising: storing one or more user programmable instructions into a configuration memory; providing at least one of the user programmable instructions to one or more structural logic elements, the structural logic elements to perform a corresponding user programmed logic function according to the received user programmable instructions; and dynamically reprogramming the configuration memory with at least another user programmable instruction that, when provided to the structural logic elements, cause the structural logic elements to perform corresponding user programmed logic functions. according to the received user programmable instructions
 18. The method according to claim 17 includes identifying one or more of the stored user programmable instruction to provide to the structural logic elements according to an input received from a system controller.
 19. The method according to claim 18 includes identifying a location in the configuration memory to load the user programmable instruction from the system controller during the dynamic reprogramming.
 20. The method according to claim 19 includes writing a new set of user programmable instructions to the configuration memory while the stored user programmable instructions are currently being read and controlling the structural logic elements; and dynamically reconfiguring the structural logic elements to perform a new function according to the new set of user programmable instructions in response to a system event. 